// 深度克隆
const deepClone = (source) => {
	// if (!isObject(source)) return source; //如果不是対象的话直接返回
	let target = Array.isArray(source) ? [] : {} //数组兼容
	for (var k in source) {
		if (source.hasOwnProperty(k)) {
			if (typeof source[k] === 'object') {
				target[k] = deepClone(source[k])
			} else {
				target[k] = source[k]
			}
		}
	}
	return target
}
// 两个対象石否相等
/**
 * 判断此対象是否是Object类型
 * @param {Object} obj  
 */
function isObject(obj) {
	return Object.prototype.toString.call(obj) === '[object Object]';
};
/**
 * 判断此类型是否是Array类型
 * @param {Array} arr 
 */
function isArray(arr) {
	return Object.prototype.toString.call(arr) === '[object Array]';
};
/**
 *  深度比较两个対象是否相同
 * @param {Object} oldData 
 * @param {Object} newData 
 */
function isObjectValueEqual(oldData, newData) {
	//       类型为基本类型时,如果相同,则返回true
	if (oldData === newData) return true;
	if (isObject(oldData) && isObject(newData) && Object.keys(oldData).length === Object.keys(newData).length) {
		//      类型为対象并且元素个数相同

		//      遍历所有対象中所有属性,判断元素是否相同
		for (const key in oldData) {
			if (oldData.hasOwnProperty(key)) {
				if (!isObjectValueEqual(oldData[key], newData[key]))
					//      対象中具有不相同属性 返回false
					return false;
			}
		}
	} else if (isArray(oldData) && isArray(oldData) && oldData.length === newData.length) {
		//      类型为数组并且数组长度相同

		for (let i = 0, length = oldData.length; i < length; i++) {
			if (!isObjectValueEqual(oldData[i], newData[i]))
				//      如果数组元素中具有不相同元素,返回false
				return false;
		}
	} else {
		//      其它类型,均返回false
		return false;
	}

	//      走到这里,说明数组或者対象中所有元素都相同,返回true
	return true;
};
// null=>''
function changeNull(obj) {
	for (let key in obj) {
		if (obj[key] == null) {
			obj[key] = '';
		}
	}
	return obj
}

export default { deepClone, isObjectValueEqual, changeNull }